\hypertarget{class_lecteur}{
\section{\-Référence de la classe \-Lecteur}
\label{class_lecteur}\index{\-Lecteur@{\-Lecteur}}
}
\subsection*{\-Fonctions membres publiques}
\begin{DoxyCompactItemize}
\item 
\hyperlink{class_lecteur_a30f8ed6804dcae8167c1a033bff0fa06}{\-Lecteur} (string fich)
\begin{DoxyCompactList}\small\item\em \-Constructeur de \hyperlink{class_lecteur}{\-Lecteur}. \end{DoxyCompactList}\item 
\hyperlink{class_lecteur_a01596daff7f0557454dcd056846df96a}{\-Lecteur} (\-Lecteur\-Symbole $\ast$lecs)
\begin{DoxyCompactList}\small\item\em \-Constructeur de \hyperlink{class_lecteur}{\-Lecteur}. \end{DoxyCompactList}\item 
\hypertarget{class_lecteur_ade99e3f98b4080ba5954d0256f84b6fa}{
virtual \hyperlink{class_lecteur_ade99e3f98b4080ba5954d0256f84b6fa}{$\sim$\-Lecteur} ()}
\label{class_lecteur_ade99e3f98b4080ba5954d0256f84b6fa}

\begin{DoxyCompactList}\small\item\em \-Destructeur virtuel de \hyperlink{class_lecteur}{\-Lecteur}. \end{DoxyCompactList}\item 
virtual \-Noeud $\ast$ \hyperlink{class_lecteur_af6905181af3dd0f5d39f4066e7645c37}{seq\-Inst} ()
\begin{DoxyCompactList}\small\item\em \-Fonction virtuelle pour créer un noeud contenant une séquence d'instruction. \-La fonction vérifie que la syntaxe d'une séquence d'instruction est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. \end{DoxyCompactList}\item 
virtual \-Noeud $\ast$ \hyperlink{class_lecteur_a1d007bbff6e94cd908e3ab155f44f11c}{inst} ()
\begin{DoxyCompactList}\small\item\em \-Fonction virtuelle pour créer un noeud contenant une séquence d'instruction. \-La syntaxe diffère un peu entre \-Lecteur\-Fonction et \-Lecteur\-Programme. \-La fonction vérifie que la syntaxe d'une instruction est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$seq\-\_\-inst$>$ \-:\-:= $<$inst$>$ ; \{ $<$inst$>$ ; \}. \end{DoxyCompactList}\item 
virtual \-Noeud $\ast$ \hyperlink{class_lecteur_a09523b80b9771c0ee2312f9937af551e}{affectation} ()
\begin{DoxyCompactList}\small\item\em \-Fonction virtuelle pour créer un noeud contenant une affectation. \-La syntaxe diffère un peu entre \-Lecteur\-Fonction et \-Lecteur\-Programme. \-La fonction vérifie que la syntaxe d'une affectation est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst$>$ \-:\-:= $<$affectation$>$ $|$ $<$inst\-Si$>$ $|$ $<$inst\-Tq$>$ $|$ $<$inst\-Repeter$>$ \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_a3654183a7765f2cbdf62c30bed78be86}{expression} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant une expression \-La fonction vérifie que la syntaxe d'une expression est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$expression$>$ \-:\-:= $<$terme$>$ \{ $<$op\-Add$>$ $<$terme$>$ \}. \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_a282d90d172cdcdfce0b24db6b452710a}{facteur} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant un facteur \-La fonction vérifie que la syntaxe d'unfacteur est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$facteur$>$ \-:\-:= $<$entier$>$ $|$ $<$variable$>$ $|$ $<$op\-Unaire$>$ $<$exp\-Bool$>$ $|$ ( $<$exp\-Bool$>$ ) $|$ $<$chaine$>$ $|$ $<$booleen$>$ \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_a01333abcd3be15385dbb950e4a55fd03}{terme} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant un terme. \-La fonction vérifie que la syntaxe d'un terme est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$terme$>$ \-:\-:= $<$facteur$>$ \{ $<$op\-Mult$>$ $<$facteur$>$ \}. \end{DoxyCompactList}\item 
\-Symbole \hyperlink{class_lecteur_acac0e9619f53fedfd120c61851d49575}{op\-Add} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un symbole contenant l'opération lue. op\-Add gère les opérations les moins prioritaires. \-La fonction vérifie que l'opération lue est bien + ou -\/ . $<$op\-Add$>$ \-:\-:= + $|$ -\/. \end{DoxyCompactList}\item 
\-Symbole \hyperlink{class_lecteur_a5369eac8f623ff3552f64694911172c3}{op\-Mult} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un symbole contenant l'opération lue. op\-Mult gère les opérations les plus prioritaires. \-La fonction vérifie que l'opération lue est bien $\ast$ ou / . $<$op\-Add$>$ \-:\-:= $\ast$ $|$ /. \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_a15855120778d49ca17de2737e018d1bf}{exp\-Bool} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant une expression booléenne. \-La fonction vérifie que la syntaxe d'une expression booléenne est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$exp\-Bool$>$ \-:\-:= $<$exp\-Bool\-Et$>$ \{ $<$op\-Bool\-Ou$>$ $<$exp\-Bool\-Et$>$ \}. \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_abf53ada12359e53e3de880f060373257}{exp\-Bool\-Et} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant une expression booléenne non prioritaire (opération \char`\"{}et\char`\"{} ). \-La fonction vérifie que la syntaxe d'une expression booléenne type \char`\"{}\-E\-T\char`\"{} est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$exp\-Bool\-Et$>$ \-:\-:= $<$relation$>$ \{$<$op\-Bool\-Et$>$ $<$relation$>$ \}. \end{DoxyCompactList}\item 
\-Symbole \hyperlink{class_lecteur_a328377666a6cb1bded22261a09b4557c}{op\-Bool\-Et} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un symbole contenant l'opération lue. \hyperlink{class_lecteur_a328377666a6cb1bded22261a09b4557c}{op\-Bool\-Et()} gère l'opération \char`\"{}et\char`\"{}. \-La fonction vérifie que l'opération lue est bien \char`\"{}et\char`\"{} . $<$op\-Add$>$ \-:\-:= et. \end{DoxyCompactList}\item 
\-Symbole \hyperlink{class_lecteur_a02124bad13ec818692651daa01f6894f}{op\-Bool\-Ou} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un symbole contenant l'opération lue. \hyperlink{class_lecteur_a02124bad13ec818692651daa01f6894f}{op\-Bool\-Ou()} gère l'opération \char`\"{}ou\char`\"{}. \-La fonction vérifie que l'opération lue est bien \char`\"{}ou\char`\"{} . $<$op\-Add$>$ \-:\-:= ou. \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_a878437876a5df20f5695342c84d3b58a}{relation} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant une relation. \-La fonction vérifie que la syntaxe d'une relation est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$relation$>$ \-:\-:= $<$expression$>$ \{ $<$op\-Rel$>$ $<$expression$>$ \}. \end{DoxyCompactList}\item 
\-Symbole \hyperlink{class_lecteur_a3627b88226070eea86efea0272ce4803}{op\-Rel} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un symbole contenant l'opération de comparaison lue. \-La fonction vérifie que l'opération lue est bien == $|$ != $|$ $<$ $|$ $<$= $|$ $>$ $|$ $>$= . $<$op\-Rel$>$ \-:\-:= == $|$ != $|$ $<$ $|$ $<$= $|$ $>$ $|$ $>$=. \end{DoxyCompactList}\item 
\-Symbole \hyperlink{class_lecteur_a4a9b395afba6ca83dc002eda18acbce9}{op\-Unaire} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un symbole contenant l'opération unaire lue. (opération ne s'appliquant qu'à un opérande) \-La fonction vérifie que l'opération lue est bien -\/ $|$ non . $<$op\-Unaire$>$ \-:\-:= -\/ $|$ non. \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_a756a61847bb35053974cfbae62e94936}{inst\-Si} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant une instruction si. \-La fonction vérifie que la syntaxe d'une instruction si est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Si$>$ \-:\-:= si ( $<$exp\-Bool$>$ ) alors $<$seq\-Inst$>$ \{ sinonsi ( $<$exp\-Bool$>$ ) alors $<$seq\-Inst$>$ \} \mbox{[} sinon $<$seq\-Inst$>$ \mbox{]} finsi. \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_a4cac39457474924c75fe03ae05ff98f6}{inst\-Tq} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant une instruction \-Tant \-Que... \-Faire. \-La fonction vérifie que la syntaxe d'une instruction \-Tant \-Que... \-Faire est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Tq$>$ \-:\-:= tantque ( $<$exp\-Bool$>$ ) faire $<$seq\-Inst$>$ fintantque. \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_a7a137cd5bb8851af3165cef6edd67ab7}{inst\-Repeter} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant une instruction \-Répéter...\-Jusqu'à. \-La fonction vérifie que la syntaxe d'une instruction \-Répéter...\-Jusqu'à est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Repeter$>$ \-:\-:= repeter $<$seq\-Inst$>$ jusqua ( $<$exp\-Bool$>$ ) \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_aa7545506f58858876f9bb7fb6f70e33e}{inst\-Pour} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant une instruction \-Pour...\-Faire . \-La fonction vérifie que la syntaxe d'une instruction \-Pour...\-Faire est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Pour$>$ \-:\-:= pour ( $<$affectation$>$ ; $<$exp\-Bool$>$ ; $<$affectation$>$ ) faire $<$seq\-Inst$>$ finpour. \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_abfa270b28131ecca0bbbee37113b0235}{inst\-Lire} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant une instruction \-Lire . \-La fonction vérifie que la syntaxe d'une instruction \-Lire est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Lire$>$ \-:\-:= lire ( $<$variable$>$ ) \end{DoxyCompactList}\item 
\-Noeud $\ast$ \hyperlink{class_lecteur_ad52aed26904c04a388da6f0441b117c4}{inst\-Ecrire} ()
\begin{DoxyCompactList}\small\item\em \-Fonction pour créer un noeud contenant une instruction \-Ecrire . \-La fonction vérifie que la syntaxe d'une instruction \-Lire est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Ecrire$>$ \-:\-:= ecrire ( $<$expression$>$ $|$ $<$chaine$>$ ) \end{DoxyCompactList}\item 
void \hyperlink{class_lecteur_a9d2d4603be5fe66d27fc9e600eccc0f8}{tester\-Sym\-Cour} (string ch)
\begin{DoxyCompactList}\small\item\em \-Fonction qui test le symbole courant en le comparant avec ch. \-Si le \-Symbole courant a la même valeur que ch ou est du type décrit par ch, le programme continue, sinon, une erreur est levée. \end{DoxyCompactList}\item 
void \hyperlink{class_lecteur_a3f78b6d315fa98a3929140e91fc7ce04}{sauter\-Sym\-Cour} (string ch)
\begin{DoxyCompactList}\small\item\em \-Fonction qui test le symbole courant en le comparant avec ch et passe au mot suivant si aucune erreur est levée. \-Si le \-Symbole courant a la même valeur que ch ou est du type décrit par ch, on passe au symbole suivant, sinon, une erreur est levée. \end{DoxyCompactList}\item 
void \hyperlink{class_lecteur_a0cb057e580dcb526cd45768808f0487c}{erreur} (string mess)
\begin{DoxyCompactList}\small\item\em \-Fonction qui écrit un message d'erreur dans l'invite de commande. le message d'erreur indique la ligne et le colonne sur laquelle lerreur a été levée. \-Elle précise quelle type de symbole était attendu et celui trouvé. \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{\-Attributs protégés}
\begin{DoxyCompactItemize}
\item 
\hypertarget{class_lecteur_aa8bcc015d13efb1db20bc8e75e63150f}{
\-Lecteur\-Symbole $\ast$ {\bfseries ls}}
\label{class_lecteur_aa8bcc015d13efb1db20bc8e75e63150f}

\item 
\hypertarget{class_lecteur_a55fcc2200167912e374c96f4603734ef}{
\-Noeud $\ast$ {\bfseries arbre}}
\label{class_lecteur_a55fcc2200167912e374c96f4603734ef}

\item 
\hypertarget{class_lecteur_ad67c21c92ca6990a8855e9dee4fc034e}{
\-Table\-Symboles {\bfseries ts}}
\label{class_lecteur_ad67c21c92ca6990a8855e9dee4fc034e}

\end{DoxyCompactItemize}


\subsection{\-Documentation des constructeurs et destructeur}
\hypertarget{class_lecteur_a30f8ed6804dcae8167c1a033bff0fa06}{
\index{\-Lecteur@{\-Lecteur}!\-Lecteur@{\-Lecteur}}
\index{\-Lecteur@{\-Lecteur}!Lecteur@{\-Lecteur}}
\subsubsection[{\-Lecteur}]{\setlength{\rightskip}{0pt plus 5cm}\-Lecteur\-::\-Lecteur (
\begin{DoxyParamCaption}
\item[{string}]{fich}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a30f8ed6804dcae8167c1a033bff0fa06}


\-Constructeur de \hyperlink{class_lecteur}{\-Lecteur}. 


\begin{DoxyParams}{\-Paramètres}
{\em fich} & \-Chaîne indiquant le chemin du fichier à analyser. ( =$>$ \-Lecteur\-Programme ) \\
\hline
\end{DoxyParams}
\hypertarget{class_lecteur_a01596daff7f0557454dcd056846df96a}{
\index{\-Lecteur@{\-Lecteur}!\-Lecteur@{\-Lecteur}}
\index{\-Lecteur@{\-Lecteur}!Lecteur@{\-Lecteur}}
\subsubsection[{\-Lecteur}]{\setlength{\rightskip}{0pt plus 5cm}\-Lecteur\-::\-Lecteur (
\begin{DoxyParamCaption}
\item[{\-Lecteur\-Symbole $\ast$}]{lecs}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a01596daff7f0557454dcd056846df96a}


\-Constructeur de \hyperlink{class_lecteur}{\-Lecteur}. 


\begin{DoxyParams}{\-Paramètres}
{\em lecs} & \-Pointeur sur un \hyperlink{class_lecteur}{\-Lecteur} de \-Symbole. ( =$>$ \hyperlink{class_lecteur}{\-Lecteur} \-Fonction ) \\
\hline
\end{DoxyParams}


\subsection{\-Documentation des fonctions membres}
\hypertarget{class_lecteur_a09523b80b9771c0ee2312f9937af551e}{
\index{\-Lecteur@{\-Lecteur}!affectation@{affectation}}
\index{affectation@{affectation}!Lecteur@{\-Lecteur}}
\subsubsection[{affectation}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::affectation (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}virtual\mbox{]}}}}
\label{class_lecteur_a09523b80b9771c0ee2312f9937af551e}


\-Fonction virtuelle pour créer un noeud contenant une affectation. \-La syntaxe diffère un peu entre \-Lecteur\-Fonction et \-Lecteur\-Programme. \-La fonction vérifie que la syntaxe d'une affectation est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst$>$ \-:\-:= $<$affectation$>$ $|$ $<$inst\-Si$>$ $|$ $<$inst\-Tq$>$ $|$ $<$inst\-Repeter$>$ 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une affectation. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a0cb057e580dcb526cd45768808f0487c}{
\index{\-Lecteur@{\-Lecteur}!erreur@{erreur}}
\index{erreur@{erreur}!Lecteur@{\-Lecteur}}
\subsubsection[{erreur}]{\setlength{\rightskip}{0pt plus 5cm}void \-Lecteur\-::erreur (
\begin{DoxyParamCaption}
\item[{string}]{mess}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a0cb057e580dcb526cd45768808f0487c}


\-Fonction qui écrit un message d'erreur dans l'invite de commande. le message d'erreur indique la ligne et le colonne sur laquelle lerreur a été levée. \-Elle précise quelle type de symbole était attendu et celui trouvé. 


\begin{DoxyParams}{\-Paramètres}
{\em ch} & \-Chaine représentant le \-Symbole qui était attendu. \\
\hline
\end{DoxyParams}
\hypertarget{class_lecteur_a15855120778d49ca17de2737e018d1bf}{
\index{\-Lecteur@{\-Lecteur}!exp\-Bool@{exp\-Bool}}
\index{exp\-Bool@{exp\-Bool}!Lecteur@{\-Lecteur}}
\subsubsection[{exp\-Bool}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::exp\-Bool (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a15855120778d49ca17de2737e018d1bf}


\-Fonction pour créer un noeud contenant une expression booléenne. \-La fonction vérifie que la syntaxe d'une expression booléenne est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$exp\-Bool$>$ \-:\-:= $<$exp\-Bool\-Et$>$ \{ $<$op\-Bool\-Ou$>$ $<$exp\-Bool\-Et$>$ \}. 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur un \-Noeud contenant l'expression booléenne complète. (composée d'exp\-Bool\-Et() et d'exp\-Bool\-Ou() 
\end{DoxyReturn}
\hypertarget{class_lecteur_abf53ada12359e53e3de880f060373257}{
\index{\-Lecteur@{\-Lecteur}!exp\-Bool\-Et@{exp\-Bool\-Et}}
\index{exp\-Bool\-Et@{exp\-Bool\-Et}!Lecteur@{\-Lecteur}}
\subsubsection[{exp\-Bool\-Et}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::exp\-Bool\-Et (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_abf53ada12359e53e3de880f060373257}


\-Fonction pour créer un noeud contenant une expression booléenne non prioritaire (opération \char`\"{}et\char`\"{} ). \-La fonction vérifie que la syntaxe d'une expression booléenne type \char`\"{}\-E\-T\char`\"{} est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$exp\-Bool\-Et$>$ \-:\-:= $<$relation$>$ \{$<$op\-Bool\-Et$>$ $<$relation$>$ \}. 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une expression booléeene type \char`\"{}\-E\-T\char`\"{}. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a3654183a7765f2cbdf62c30bed78be86}{
\index{\-Lecteur@{\-Lecteur}!expression@{expression}}
\index{expression@{expression}!Lecteur@{\-Lecteur}}
\subsubsection[{expression}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::expression (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a3654183a7765f2cbdf62c30bed78be86}


\-Fonction pour créer un noeud contenant une expression \-La fonction vérifie que la syntaxe d'une expression est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$expression$>$ \-:\-:= $<$terme$>$ \{ $<$op\-Add$>$ $<$terme$>$ \}. 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une expression. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a282d90d172cdcdfce0b24db6b452710a}{
\index{\-Lecteur@{\-Lecteur}!facteur@{facteur}}
\index{facteur@{facteur}!Lecteur@{\-Lecteur}}
\subsubsection[{facteur}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::facteur (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a282d90d172cdcdfce0b24db6b452710a}


\-Fonction pour créer un noeud contenant un facteur \-La fonction vérifie que la syntaxe d'unfacteur est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$facteur$>$ \-:\-:= $<$entier$>$ $|$ $<$variable$>$ $|$ $<$op\-Unaire$>$ $<$exp\-Bool$>$ $|$ ( $<$exp\-Bool$>$ ) $|$ $<$chaine$>$ $|$ $<$booleen$>$ 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant un facteur. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a1d007bbff6e94cd908e3ab155f44f11c}{
\index{\-Lecteur@{\-Lecteur}!inst@{inst}}
\index{inst@{inst}!Lecteur@{\-Lecteur}}
\subsubsection[{inst}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::inst (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}virtual\mbox{]}}}}
\label{class_lecteur_a1d007bbff6e94cd908e3ab155f44f11c}


\-Fonction virtuelle pour créer un noeud contenant une séquence d'instruction. \-La syntaxe diffère un peu entre \-Lecteur\-Fonction et \-Lecteur\-Programme. \-La fonction vérifie que la syntaxe d'une instruction est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$seq\-\_\-inst$>$ \-:\-:= $<$inst$>$ ; \{ $<$inst$>$ ; \}. 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une séquence d'instruction. 
\end{DoxyReturn}
\hypertarget{class_lecteur_ad52aed26904c04a388da6f0441b117c4}{
\index{\-Lecteur@{\-Lecteur}!inst\-Ecrire@{inst\-Ecrire}}
\index{inst\-Ecrire@{inst\-Ecrire}!Lecteur@{\-Lecteur}}
\subsubsection[{inst\-Ecrire}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::inst\-Ecrire (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_ad52aed26904c04a388da6f0441b117c4}


\-Fonction pour créer un noeud contenant une instruction \-Ecrire . \-La fonction vérifie que la syntaxe d'une instruction \-Lire est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Ecrire$>$ \-:\-:= ecrire ( $<$expression$>$ $|$ $<$chaine$>$ ) 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une instruction \-Ecrire . 
\end{DoxyReturn}
\hypertarget{class_lecteur_abfa270b28131ecca0bbbee37113b0235}{
\index{\-Lecteur@{\-Lecteur}!inst\-Lire@{inst\-Lire}}
\index{inst\-Lire@{inst\-Lire}!Lecteur@{\-Lecteur}}
\subsubsection[{inst\-Lire}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::inst\-Lire (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_abfa270b28131ecca0bbbee37113b0235}


\-Fonction pour créer un noeud contenant une instruction \-Lire . \-La fonction vérifie que la syntaxe d'une instruction \-Lire est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Lire$>$ \-:\-:= lire ( $<$variable$>$ ) 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une instruction \-Lire . 
\end{DoxyReturn}
\hypertarget{class_lecteur_aa7545506f58858876f9bb7fb6f70e33e}{
\index{\-Lecteur@{\-Lecteur}!inst\-Pour@{inst\-Pour}}
\index{inst\-Pour@{inst\-Pour}!Lecteur@{\-Lecteur}}
\subsubsection[{inst\-Pour}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::inst\-Pour (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_aa7545506f58858876f9bb7fb6f70e33e}


\-Fonction pour créer un noeud contenant une instruction \-Pour...\-Faire . \-La fonction vérifie que la syntaxe d'une instruction \-Pour...\-Faire est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Pour$>$ \-:\-:= pour ( $<$affectation$>$ ; $<$exp\-Bool$>$ ; $<$affectation$>$ ) faire $<$seq\-Inst$>$ finpour. 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une instruction \-Pour...\-Faire . 
\end{DoxyReturn}
\hypertarget{class_lecteur_a7a137cd5bb8851af3165cef6edd67ab7}{
\index{\-Lecteur@{\-Lecteur}!inst\-Repeter@{inst\-Repeter}}
\index{inst\-Repeter@{inst\-Repeter}!Lecteur@{\-Lecteur}}
\subsubsection[{inst\-Repeter}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::inst\-Repeter (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a7a137cd5bb8851af3165cef6edd67ab7}


\-Fonction pour créer un noeud contenant une instruction \-Répéter...\-Jusqu'à. \-La fonction vérifie que la syntaxe d'une instruction \-Répéter...\-Jusqu'à est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Repeter$>$ \-:\-:= repeter $<$seq\-Inst$>$ jusqua ( $<$exp\-Bool$>$ ) 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une instruction \-Répéter...\-Jusqu'à. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a756a61847bb35053974cfbae62e94936}{
\index{\-Lecteur@{\-Lecteur}!inst\-Si@{inst\-Si}}
\index{inst\-Si@{inst\-Si}!Lecteur@{\-Lecteur}}
\subsubsection[{inst\-Si}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::inst\-Si (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a756a61847bb35053974cfbae62e94936}


\-Fonction pour créer un noeud contenant une instruction si. \-La fonction vérifie que la syntaxe d'une instruction si est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Si$>$ \-:\-:= si ( $<$exp\-Bool$>$ ) alors $<$seq\-Inst$>$ \{ sinonsi ( $<$exp\-Bool$>$ ) alors $<$seq\-Inst$>$ \} \mbox{[} sinon $<$seq\-Inst$>$ \mbox{]} finsi. 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une instruction si. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a4cac39457474924c75fe03ae05ff98f6}{
\index{\-Lecteur@{\-Lecteur}!inst\-Tq@{inst\-Tq}}
\index{inst\-Tq@{inst\-Tq}!Lecteur@{\-Lecteur}}
\subsubsection[{inst\-Tq}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::inst\-Tq (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a4cac39457474924c75fe03ae05ff98f6}


\-Fonction pour créer un noeud contenant une instruction \-Tant \-Que... \-Faire. \-La fonction vérifie que la syntaxe d'une instruction \-Tant \-Que... \-Faire est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$inst\-Tq$>$ \-:\-:= tantque ( $<$exp\-Bool$>$ ) faire $<$seq\-Inst$>$ fintantque. 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une instruction \-Tant \-Que... \-Faire. 
\end{DoxyReturn}
\hypertarget{class_lecteur_acac0e9619f53fedfd120c61851d49575}{
\index{\-Lecteur@{\-Lecteur}!op\-Add@{op\-Add}}
\index{op\-Add@{op\-Add}!Lecteur@{\-Lecteur}}
\subsubsection[{op\-Add}]{\setlength{\rightskip}{0pt plus 5cm}\-Symbole \-Lecteur\-::op\-Add (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_acac0e9619f53fedfd120c61851d49575}


\-Fonction pour créer un symbole contenant l'opération lue. op\-Add gère les opérations les moins prioritaires. \-La fonction vérifie que l'opération lue est bien + ou -\/ . $<$op\-Add$>$ \-:\-:= + $|$ -\/. 

\begin{DoxyReturn}{\-Renvoie}
\-Symbole contenant l'opération du noeud actuellement analysé. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a328377666a6cb1bded22261a09b4557c}{
\index{\-Lecteur@{\-Lecteur}!op\-Bool\-Et@{op\-Bool\-Et}}
\index{op\-Bool\-Et@{op\-Bool\-Et}!Lecteur@{\-Lecteur}}
\subsubsection[{op\-Bool\-Et}]{\setlength{\rightskip}{0pt plus 5cm}\-Lecteur\-::op\-Bool\-Et (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a328377666a6cb1bded22261a09b4557c}


\-Fonction pour créer un symbole contenant l'opération lue. \hyperlink{class_lecteur_a328377666a6cb1bded22261a09b4557c}{op\-Bool\-Et()} gère l'opération \char`\"{}et\char`\"{}. \-La fonction vérifie que l'opération lue est bien \char`\"{}et\char`\"{} . $<$op\-Add$>$ \-:\-:= et. 

\begin{DoxyReturn}{\-Renvoie}
\-Symbole contenant l'opération du noeud actuellement analysé. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a02124bad13ec818692651daa01f6894f}{
\index{\-Lecteur@{\-Lecteur}!op\-Bool\-Ou@{op\-Bool\-Ou}}
\index{op\-Bool\-Ou@{op\-Bool\-Ou}!Lecteur@{\-Lecteur}}
\subsubsection[{op\-Bool\-Ou}]{\setlength{\rightskip}{0pt plus 5cm}\-Lecteur\-::op\-Bool\-Ou (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a02124bad13ec818692651daa01f6894f}


\-Fonction pour créer un symbole contenant l'opération lue. \hyperlink{class_lecteur_a02124bad13ec818692651daa01f6894f}{op\-Bool\-Ou()} gère l'opération \char`\"{}ou\char`\"{}. \-La fonction vérifie que l'opération lue est bien \char`\"{}ou\char`\"{} . $<$op\-Add$>$ \-:\-:= ou. 

\begin{DoxyReturn}{\-Renvoie}
\-Symbole contenant l'opération du noeud actuellement analysé. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a5369eac8f623ff3552f64694911172c3}{
\index{\-Lecteur@{\-Lecteur}!op\-Mult@{op\-Mult}}
\index{op\-Mult@{op\-Mult}!Lecteur@{\-Lecteur}}
\subsubsection[{op\-Mult}]{\setlength{\rightskip}{0pt plus 5cm}\-Symbole \-Lecteur\-::op\-Mult (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a5369eac8f623ff3552f64694911172c3}


\-Fonction pour créer un symbole contenant l'opération lue. op\-Mult gère les opérations les plus prioritaires. \-La fonction vérifie que l'opération lue est bien $\ast$ ou / . $<$op\-Add$>$ \-:\-:= $\ast$ $|$ /. 

\begin{DoxyReturn}{\-Renvoie}
\-Symbole contenant l'opération du noeud actuellement analysé. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a3627b88226070eea86efea0272ce4803}{
\index{\-Lecteur@{\-Lecteur}!op\-Rel@{op\-Rel}}
\index{op\-Rel@{op\-Rel}!Lecteur@{\-Lecteur}}
\subsubsection[{op\-Rel}]{\setlength{\rightskip}{0pt plus 5cm}\-Symbole \-Lecteur\-::op\-Rel (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a3627b88226070eea86efea0272ce4803}


\-Fonction pour créer un symbole contenant l'opération de comparaison lue. \-La fonction vérifie que l'opération lue est bien == $|$ != $|$ $<$ $|$ $<$= $|$ $>$ $|$ $>$= . $<$op\-Rel$>$ \-:\-:= == $|$ != $|$ $<$ $|$ $<$= $|$ $>$ $|$ $>$=. 

\begin{DoxyReturn}{\-Renvoie}
\-Symbole contenant l'opération de comparaison du noeud actuellement analysé. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a4a9b395afba6ca83dc002eda18acbce9}{
\index{\-Lecteur@{\-Lecteur}!op\-Unaire@{op\-Unaire}}
\index{op\-Unaire@{op\-Unaire}!Lecteur@{\-Lecteur}}
\subsubsection[{op\-Unaire}]{\setlength{\rightskip}{0pt plus 5cm}\-Symbole \-Lecteur\-::op\-Unaire (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a4a9b395afba6ca83dc002eda18acbce9}


\-Fonction pour créer un symbole contenant l'opération unaire lue. (opération ne s'appliquant qu'à un opérande) \-La fonction vérifie que l'opération lue est bien -\/ $|$ non . $<$op\-Unaire$>$ \-:\-:= -\/ $|$ non. 

\begin{DoxyReturn}{\-Renvoie}
\-Symbole contenant l'opération unaire du noeud actuellement analysé. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a878437876a5df20f5695342c84d3b58a}{
\index{\-Lecteur@{\-Lecteur}!relation@{relation}}
\index{relation@{relation}!Lecteur@{\-Lecteur}}
\subsubsection[{relation}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::relation (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a878437876a5df20f5695342c84d3b58a}


\-Fonction pour créer un noeud contenant une relation. \-La fonction vérifie que la syntaxe d'une relation est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$relation$>$ \-:\-:= $<$expression$>$ \{ $<$op\-Rel$>$ $<$expression$>$ \}. 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une relation. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a3f78b6d315fa98a3929140e91fc7ce04}{
\index{\-Lecteur@{\-Lecteur}!sauter\-Sym\-Cour@{sauter\-Sym\-Cour}}
\index{sauter\-Sym\-Cour@{sauter\-Sym\-Cour}!Lecteur@{\-Lecteur}}
\subsubsection[{sauter\-Sym\-Cour}]{\setlength{\rightskip}{0pt plus 5cm}void \-Lecteur\-::sauter\-Sym\-Cour (
\begin{DoxyParamCaption}
\item[{string}]{ch}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a3f78b6d315fa98a3929140e91fc7ce04}


\-Fonction qui test le symbole courant en le comparant avec ch et passe au mot suivant si aucune erreur est levée. \-Si le \-Symbole courant a la même valeur que ch ou est du type décrit par ch, on passe au symbole suivant, sinon, une erreur est levée. 


\begin{DoxyParams}{\-Paramètres}
{\em ch} & \-Chaine représentant une valeur ou le type du symbole que l'on veut comparer avec le symbole courant. \\
\hline
\end{DoxyParams}
\hypertarget{class_lecteur_af6905181af3dd0f5d39f4066e7645c37}{
\index{\-Lecteur@{\-Lecteur}!seq\-Inst@{seq\-Inst}}
\index{seq\-Inst@{seq\-Inst}!Lecteur@{\-Lecteur}}
\subsubsection[{seq\-Inst}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::seq\-Inst (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}virtual\mbox{]}}}}
\label{class_lecteur_af6905181af3dd0f5d39f4066e7645c37}


\-Fonction virtuelle pour créer un noeud contenant une séquence d'instruction. \-La fonction vérifie que la syntaxe d'une séquence d'instruction est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant une séquence d'instruction. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a01333abcd3be15385dbb950e4a55fd03}{
\index{\-Lecteur@{\-Lecteur}!terme@{terme}}
\index{terme@{terme}!Lecteur@{\-Lecteur}}
\subsubsection[{terme}]{\setlength{\rightskip}{0pt plus 5cm}\-Noeud $\ast$ \-Lecteur\-::terme (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a01333abcd3be15385dbb950e4a55fd03}


\-Fonction pour créer un noeud contenant un terme. \-La fonction vérifie que la syntaxe d'un terme est respectée. \-Les nouveaux symboles rencontrés sont ajouté à la table des symboles. $<$terme$>$ \-:\-:= $<$facteur$>$ \{ $<$op\-Mult$>$ $<$facteur$>$ \}. 

\begin{DoxyReturn}{\-Renvoie}
\-Pointeur sur noeud contenant un terme. 
\end{DoxyReturn}
\hypertarget{class_lecteur_a9d2d4603be5fe66d27fc9e600eccc0f8}{
\index{\-Lecteur@{\-Lecteur}!tester\-Sym\-Cour@{tester\-Sym\-Cour}}
\index{tester\-Sym\-Cour@{tester\-Sym\-Cour}!Lecteur@{\-Lecteur}}
\subsubsection[{tester\-Sym\-Cour}]{\setlength{\rightskip}{0pt plus 5cm}void \-Lecteur\-::tester\-Sym\-Cour (
\begin{DoxyParamCaption}
\item[{string}]{ch}
\end{DoxyParamCaption}
)}}
\label{class_lecteur_a9d2d4603be5fe66d27fc9e600eccc0f8}


\-Fonction qui test le symbole courant en le comparant avec ch. \-Si le \-Symbole courant a la même valeur que ch ou est du type décrit par ch, le programme continue, sinon, une erreur est levée. 


\begin{DoxyParams}{\-Paramètres}
{\em ch} & \-Chaine représentant une valeur ou le type du symbole que l'on veut comparer avec le symbole courant. \\
\hline
\end{DoxyParams}


\-La documentation de cette classe a été générée à partir du fichier suivant \-:\begin{DoxyCompactItemize}
\item 
\hyperlink{_lecteur_8h}{\-Lecteur.\-h}\end{DoxyCompactItemize}
